home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 15 / BBS in a box XV-2.iso / Files II / Prog / M / MacPerl 4.13 source.sit / Perl Source ƒ / MacPerl / MPFile.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-02-27  |  16.3 KB  |  780 lines  |  [TEXT/MPS ]
  1. /*********************************************************************
  2. Project    :    MacPerl            -    Real Perl Application
  3. File        :    MPFile.c            -
  4. Author    :    Matthias Neeracher
  5.  
  6. A lot of this code is borrowed from 7Edit written by
  7. Apple Developer Support UK
  8.  
  9. Language    :    MPW C
  10.  
  11. $Log: MPFile.c,v $
  12. Revision 1.1  1994/02/27  23:00:47  neeri
  13. Initial revision
  14.  
  15. Revision 0.6  1993/09/17  00:00:00  neeri
  16. Runtime version
  17.  
  18. Revision 0.5  1993/08/28  00:00:00  neeri
  19. Handle multiple preference files
  20.  
  21. Revision 0.4  1993/08/17  00:00:00  neeri
  22. Enable Save
  23.  
  24. Revision 0.3  1993/08/13  00:00:00  neeri
  25. Write bounds rectangles
  26.  
  27. Revision 0.2  1993/05/30  00:00:00  neeri
  28. Support Console Windows
  29.  
  30. Revision 0.1  1993/05/29  00:00:00  neeri
  31. Compiles correctly
  32.  
  33. *********************************************************************/
  34.  
  35. #include <Errors.h>
  36. #include <Resources.h>
  37. #include <Desk.h>
  38. #include <PLStringFuncs.h>
  39. #include <AppleEvents.h>
  40. #include <AERegistry.h>
  41. #include <StandardFile.h>
  42. #include <TFileSpec.h>
  43.  
  44. #include "MPFile.h"
  45. #include "MPSave.h"
  46.  
  47. /**-----------------------------------------------------------------------
  48.         Name:             FileError
  49.         Purpose:        Puts up an error alert.
  50.     -----------------------------------------------------------------------**/
  51.  
  52.  
  53. #pragma segment File
  54.  
  55. pascal void FileError(Str255 s, Str255 f)
  56. {
  57.     short    alertResult;
  58.  
  59.     SetCursor(&qd.arrow);
  60.     ParamText(s, f, "", "");
  61.      alertResult = Alert(ErrorAlert, nil);
  62. }
  63.  
  64. /**-----------------------------------------------------------------------
  65.         Name:             DoClose
  66.         Purpose:        Closes a window.
  67.     -----------------------------------------------------------------------**/
  68.  
  69. #pragma segment File
  70.  
  71. pascal OSErr DoClose(WindowPtr aWindow, Boolean canInteract, DescType dialogAnswer)
  72. {
  73.      DPtr    aDocument;
  74.      short   alertResult;
  75.      Str255  theName;
  76.     OSErr   myErr;
  77.  
  78.     myErr = noErr;
  79.  
  80.      if (gWCount > 0) {
  81.         aDocument = DPtrFromWindowPtr(aWindow);
  82.  
  83.         if (aDocument->kind == kDocumentWindow) {
  84.             if (aDocument->dirty)
  85.                 if (canInteract && (dialogAnswer==kAEAsk)) {
  86.                     if (aDocument->u.reg.everSaved == false)
  87.                         GetWTitle(aWindow, theName); /* Pick it up as a script may have changed it */
  88.                     else
  89.                         PLstrcpy(theName, aDocument->theFileName);
  90.     
  91.                     ParamText(theName, "", "", "");
  92.                     SetCursor(&qd.arrow);
  93.                     alertResult = Alert(SaveAlert, nil);
  94.                     switch (alertResult) {
  95.                     case aaSave:
  96.                         myErr = SaveAskingName(aDocument, canInteract);
  97.                         break;
  98.     
  99.                     case aaCancel:
  100.                         return userCanceledErr;
  101.     
  102.                     case aaDiscard:
  103.                         aDocument->dirty = false;
  104.                         break;
  105.                     }
  106.                 } else {
  107.                     if (dialogAnswer==kAEYes)
  108.                         myErr = SaveAskingName(aDocument, canInteract);
  109.                     else
  110.                         myErr = noErr; /* Don't save */
  111.                 }
  112.                 
  113.             if (!myErr) {
  114. #ifndef RUNTIME
  115.                 if (aDocument->kind == kDocumentWindow && aDocument->u.reg.numSections)
  116.                     DeRegisterAllSections(aDocument);
  117. #endif
  118.  
  119.                 CloseMyWindow(aWindow);
  120.             }
  121.         } else if (aDocument->u.cons.selected) {
  122.             if (!gQuitting) {
  123.                 SysBeep(0);
  124.     
  125.                 return userCanceledErr;
  126.             }
  127.         } else 
  128.             SaveConsole(aDocument);
  129.     } else
  130.         myErr = errAEIllegalIndex;
  131.  
  132.     return myErr;
  133. }
  134.  
  135. #pragma segment File
  136.  
  137. //  DoQuit
  138. //  saveOpt - one of kAEAsk,kAEYes,kAENo
  139. //  if kAEYes or kAEAsk then AEInteactWithUser should have been called
  140. //  before DoQuit. Assumes that it can interact if it needs to.
  141.  
  142. pascal void DoQuit(DescType saveOpt)
  143. {
  144.     WindowPeek    aWindow;
  145.     WindowPeek    nextWindow;
  146.     short            theKind;
  147.  
  148.     if (gRunningPerl && (Alert(AbortAlert, nil) == 2))
  149.         return;
  150.         
  151.     gQuitting = true;
  152.  
  153.     for (aWindow = (WindowPeek) FrontWindow(); aWindow; aWindow = nextWindow) {
  154.         nextWindow = aWindow->nextWindow;
  155.         if (Ours((WindowPtr) aWindow)) {
  156.             if (DoClose((WindowPtr) aWindow, true, saveOpt)) {
  157.                 gQuitting = false;
  158.                 
  159.                 return;
  160.             }
  161.         } else {
  162.             theKind = aWindow->windowKind;
  163.             if (theKind < 0)
  164.                 CloseDeskAcc(theKind);
  165.         }
  166.     }
  167. }
  168.  
  169. pascal Boolean GetFileFilter(ParmBlkPtr info)
  170. {
  171.     switch (info->fileParam.ioFlFndrInfo.fdType) {
  172.     case 'APPL':
  173.         switch (info->fileParam.ioFlFndrInfo.fdCreator) {
  174.         case MPRtSig:
  175.             return false;
  176.         case MPAppSig:
  177.             return !info->fileParam.ioFlLgLen;
  178.         default:
  179.             return true;
  180.         }
  181.     case 'TEXT':
  182.         return false;
  183.     default:
  184.         return true;
  185.     }
  186. }
  187.  
  188. pascal OSErr GetFile(FSSpec *theFSSpec)
  189. {
  190. #ifndef RUNTIME
  191.  
  192.     SFTypeList         myTypes = {'TEXT', 'APPL'};
  193.     StandardFileReply  reply;
  194.  
  195.     StandardGetFile(GetFileFilter, 2, myTypes, &reply);
  196.  
  197.     if (reply.sfGood) {
  198.         *theFSSpec = reply.sfFile;
  199.         return noErr;
  200.     } else
  201.         return userCanceledErr;
  202.         
  203. #else
  204.  
  205.     SFTypeList     myTypes = {'TEXT', 'APPL'};
  206.     SFReply          reply;
  207.     Point            where;
  208.  
  209.     where.h = where.v = 75;
  210.  
  211.     SFGetFile(
  212.         where, "\p", 
  213.         GetFileFilter, 2, myTypes, 
  214.         (DlgHookProcPtr) nil,
  215.         &reply);
  216.  
  217.     if (reply.good)
  218.         return WD2FSSpec(reply.vRefNum, reply.fName, theFSSpec);
  219.     else
  220.         return userCanceledErr;
  221.         
  222. #endif
  223. }
  224.  
  225. #pragma segment File
  226.  
  227. pascal OSErr DoCreate(FSSpec theSpec)
  228. {
  229.     OSErr err;
  230.  
  231. #ifndef RUNTIME
  232.     err = FSpCreate(&theSpec, MPAppSig, 'TEXT', smSystemScript);
  233. #else
  234.     err = HCreate(theSpec.vRefNum, theSpec.parID, theSpec.name, MPAppSig, 'TEXT');
  235. #endif
  236.  
  237.     if (!err)
  238.         HCreateResFile(theSpec.vRefNum, theSpec.parID, theSpec.name);
  239.     else
  240.         ShowError("\pCreating", err);
  241.  
  242.     return err;
  243. }
  244.  
  245. pascal OSErr SaveConsole(DPtr doc)
  246. {
  247.     OSErr            err;
  248.     short       resFile;
  249.     HHandle     theHHandle;
  250.     Str255        title;
  251.     Boolean        existing;
  252.     
  253.     if (gPrefsFile) {
  254.         resFile    =    CurResFile();
  255.         UseResFile(gPrefsFile);
  256.         GetWTitle(doc->theWindow, title);
  257.         
  258.         if (theHHandle = (HHandle) Get1NamedResource('TFSS', title)) {
  259.             existing = true;
  260.         } else {
  261.             existing = false;
  262.             theHHandle = (HHandle)NewHandle(sizeof(HeaderRec));
  263.         }
  264.         
  265.         HLock((Handle)theHHandle);
  266.     
  267.         (*theHHandle)->theRect     = doc->theWindow->portRect;
  268.         OffsetRect(
  269.             &(*theHHandle)->theRect,
  270.             -doc->theWindow->portBits.bounds.left,
  271.             -doc->theWindow->portBits.bounds.top);
  272.             
  273.         GetFontName((*(doc->theText))->txFont, &(*theHHandle)->theFont);
  274.         
  275.         (*theHHandle)->theSize     = (*(doc->theText))->txSize;
  276.         (*theHHandle)->lastID      = 0;
  277.         (*theHHandle)->numSections = 0;
  278.     
  279.         HUnlock((Handle)theHHandle);
  280.     
  281.         if (existing) {
  282.             ChangedResource((Handle) theHHandle);
  283.             WriteResource((Handle) theHHandle);
  284.             UpdateResFile(gPrefsFile);
  285.         } else {
  286.             AddResource((Handle)theHHandle, 'TFSS', Unique1ID('TFSS'), title);
  287.         }
  288.         
  289.         err = ResError();
  290.         
  291.         UseResFile(resFile);
  292.     }
  293.     
  294.     DoHideWindow(doc->theWindow);
  295.     TESetSelect(0, 32767, doc->theText);
  296.     TEDelete(doc->theText);
  297.     
  298.     if (doc->u.cons.fence < 32767)
  299.         doc->u.cons.fence    = 0;
  300.     
  301.     return err;
  302. } 
  303.  
  304. pascal void ApplySettings(DPtr doc, HPtr settings)
  305. {
  306.     short        fNum;
  307.     FontInfo    info;
  308.     Rect        bounds;
  309.     
  310.     GetFNum(settings->theFont, &fNum);
  311.     SetPort(doc->theWindow);
  312.     TextFont(fNum);
  313.     TextSize(settings->theSize);
  314.     GetFontInfo(&info);
  315.     
  316.     (*doc->theText)->txFont         = fNum;
  317.     (*doc->theText)->txSize         = settings->theSize;
  318.     (*doc->theText)->lineHeight    = info.ascent+info.descent+info.leading;
  319.     (*doc->theText)->fontAscent    = info.ascent;
  320.     
  321.     bounds                                = settings->theRect;
  322.     InsetRect(&bounds, 20, 20);
  323.     
  324.     if (settings->theRect.right > settings->theRect.left + 50 &&
  325.         settings->theRect.bottom > settings->theRect.top  + 50 &&
  326.         RectInRgn(&bounds, GetGrayRgn())
  327.     ) {
  328.         MoveWindow(doc->theWindow, settings->theRect.left, settings->theRect.top, false);
  329.         SizeWindow(
  330.             doc->theWindow,
  331.             settings->theRect.right - settings->theRect.left,
  332.             settings->theRect.bottom - settings->theRect.top,
  333.             false);
  334.     }
  335.         
  336.     ResizeWindow(doc);
  337. }
  338.  
  339. pascal void RestoreConsole(DPtr doc)
  340. {
  341.     short       resFile;
  342.     HHandle     theHHandle;
  343.     Str255        title;
  344.     
  345.     if (!gPrefsFile)
  346.         return;
  347.         
  348.     resFile    =    CurResFile();
  349.     UseResFile(gPrefsFile);
  350.     GetWTitle(doc->theWindow, title);
  351.     
  352.     if (theHHandle = (HHandle) Get1NamedResource('TFSS', title)) {
  353.          HLock((Handle)theHHandle);
  354.         
  355.         ApplySettings(doc, *theHHandle);
  356.         
  357.         HUnlock((Handle)theHHandle);
  358.     }
  359.     
  360.     UseResFile(resFile);
  361. }
  362.  
  363.  
  364. /** -----------------------------------------------------------------------
  365.         Name:         GetFileContents
  366.         Purpose:        Opens the document specified by theFSSpec and puts
  367.                         the contents into theDocument.
  368.      -----------------------------------------------------------------------**/
  369.  
  370. #pragma segment File
  371.  
  372. pascal OSErr GetFileContents(FSSpec spec, DPtr theDocument)
  373. {
  374.     long            theSize;
  375.     short            oldRes;
  376.     short            resFile;
  377.     short            refNum;
  378.     OSErr            err;
  379.     HHandle        aHandle;
  380.     Handle        gHandle;
  381.  
  382.     oldRes    =    CurResFile();
  383.     resFile     =    HOpenResFile(spec.vRefNum, spec.parID, spec.name, fsRdPerm);
  384.  
  385.     switch (theDocument->type) {
  386.     case kOldRuntime6Doc:
  387.     case kPlainTextDoc:
  388. #ifndef RUNTIME
  389.         if (err = HOpenDF(spec.vRefNum, spec.parID, spec.name, fsRdPerm, &refNum)) {
  390.             ShowError("\pread file - HOpenDF", err);
  391. #else
  392.         if (err = HOpen(spec.vRefNum, spec.parID, spec.name, fsRdPerm, &refNum)) {
  393.             ShowError("\pread file - HOpen", err);
  394. #endif
  395.             refNum = 0;
  396.             
  397.             goto giveUp;
  398.         }
  399.     
  400.         if (err = GetEOF(refNum, &theSize))
  401.             goto giveUp;
  402.  
  403.           gHandle = NewHandle(theSize);
  404.  
  405.         HLock(gHandle);
  406.         if (err = FSRead(refNum, &theSize, *gHandle))
  407.             return err;
  408.         HUnlock(gHandle);
  409.         FSClose(refNum);
  410.         break;
  411.         
  412. giveUp:    
  413.         if (refNum)
  414.             FSClose(refNum);
  415.             
  416.         if (resFile > -1)
  417.             CloseResFile(resFile);
  418.         
  419.         UseResFile(oldRes);
  420.         
  421.         return err;
  422.     default:
  423.         gHandle    =    Get1NamedResource('TEXT', "\p!");
  424.         
  425.         if (gHandle) 
  426.             DetachResource(gHandle);
  427.         else {
  428.             err = ResError();
  429.             
  430.             goto giveUp;
  431.         }
  432.         break;
  433.     }
  434.  
  435.     theDocument->u.reg.numSections = 0;
  436.  
  437.     if (resFile != -1) {
  438.         aHandle = nil;
  439.  
  440.         if (Count1Resources('TFSS'))
  441.             aHandle = (HHandle)Get1Resource('TFSS', 255);
  442.  
  443.         if (aHandle) {
  444.             theDocument->u.reg.numSections = (*aHandle)->numSections;
  445.             
  446.             HLock((Handle) aHandle);
  447.             ApplySettings(theDocument, *aHandle);
  448.         }
  449.  
  450.         /*
  451.             If there is a print record saved, ditch the old one
  452.             created by new document and fill this one in
  453.         */
  454.         if (Count1Resources('TFSP')) {
  455.             if (theDocument->thePrintSetup)
  456.                 DisposHandle((Handle)theDocument->thePrintSetup);
  457.  
  458.             theDocument->thePrintSetup = (THPrint)Get1Resource('TFSP', 255);
  459.               HandToHand((Handle *)&theDocument->thePrintSetup);
  460.  
  461.             PrValidate(theDocument->thePrintSetup);
  462.         }
  463.  
  464. #ifndef RUNTIME
  465.         if (theDocument->u.reg.numSections) {
  466.             ReadSectionRecords(theDocument);
  467.             ReadAllSectionResources(theDocument);
  468.         }
  469. #else
  470.         theDocument->u.reg.numSections    =    0;
  471. #endif
  472.  
  473.         CloseResFile(resFile);
  474.  
  475.         if (err = ResError()) {
  476.             ShowError("\pread file- CloseResFile", err);
  477.             return err;
  478.         }
  479.     }
  480.  
  481.     HLock(gHandle);
  482.     if (GetHandleSize(gHandle) > 32000) {
  483.         PtrToXHand(
  484.             *gHandle, 
  485.             (*theDocument->theText)->hText, 
  486.             GetHandleSize(gHandle));
  487.         
  488.         err = elvisErr;
  489.     } else
  490.         TESetText(*gHandle, GetHandleSize(gHandle), theDocument->theText);
  491.     DisposHandle(gHandle);
  492.  
  493.     if (err == fnfErr)
  494.         return noErr;
  495.     else
  496.           return err;
  497. } /* GetFileContents */
  498.  
  499.  
  500. #pragma segment File
  501.  
  502. pascal OSErr SaveAskingName(DPtr aDocument, Boolean canInteract)
  503. {
  504.     OSErr    myErr;
  505.  
  506.     if (aDocument->kind != kDocumentWindow || !aDocument->u.reg.everSaved) {
  507.  
  508.         if (canInteract) {
  509.             if (myErr = GetFileNameToSaveAs(aDocument))
  510.                 return myErr;
  511.  
  512.             if (myErr = DoSave(aDocument, aDocument->theFSSpec))
  513.                 return myErr;
  514.  
  515. #ifndef RUNTIME
  516.             AssocAllSections(aDocument);
  517. #endif
  518.  
  519.             return noErr;
  520.         } else
  521.             return errAENoUserInteraction;
  522.  
  523.     } else
  524.         return SaveUsingTemp(aDocument);
  525. }
  526.  
  527. #pragma segment File
  528.  
  529. pascal OSErr SaveUsingTemp(DPtr theDocument)
  530. {
  531.     Str255    tempName;
  532.     OSErr        err;
  533.     FSSpec    tempFSSpec;
  534.  
  535.     /*save the file to disk using a temporary file*/
  536.     /*this is the recommended way of doing things*/
  537.     /*first write out the file to disk using a temporary filename*/
  538.     /*if it is sucessfully written, exchange the temporary file with the last one saved*/
  539.     /*then delete the temporary file- so if anything goes wrong, the original version is still there*/
  540.     /*first generate the temporary filename*/
  541.  
  542.     GetTempFileName(theDocument, &tempName);
  543.     /*create this file on disk*/
  544.  
  545.     tempFSSpec = theDocument->theFSSpec;
  546.     PLstrcpy(tempFSSpec.name, tempName);
  547.  
  548.     if (err = DoCreate(tempFSSpec))
  549.         return err;
  550.  
  551.     if (err = DoSave(theDocument, tempFSSpec))
  552.         return err;
  553.     
  554. #ifndef RUNTIME
  555.     if (err = FSpExchangeFiles(&tempFSSpec, &theDocument->theFSSpec))
  556.         return err;
  557.  
  558.     /*we've exchanged the files, now delete the temporary one*/
  559.  
  560.     err = FSpDelete(&tempFSSpec);
  561. #else
  562.     err = FSpSmartMove(&tempFSSpec, &theDocument->theFSSpec);
  563. #endif
  564.     
  565.     if (!err)
  566.         theDocument->dirty = false;
  567.  
  568.     return err;
  569. }
  570.  
  571.  
  572. #pragma segment File
  573.  
  574. pascal short SaveScriptHook(short item, DialogPtr dlg, void * params)
  575. {
  576.     short                kind;
  577.     ControlHandle    type;
  578.     Rect                r;
  579.     DPtr                doc = (DPtr) params;
  580.     
  581.     if (GetWRefCon(dlg) != 'stdf')
  582.         return item;
  583.         
  584.     switch (item) {
  585.     case sfHookFirstCall:
  586.         GetDItem(dlg, ssd_Type, &kind, (Handle *) &type, &r);
  587.         SetCtlValue(type, doc->type);
  588.         
  589.         return sfHookFirstCall;
  590.     case ssd_Type:
  591.         GetDItem(dlg, item, &kind, (Handle *) &type, &r);
  592.         
  593.         doc->type = (DocType) GetCtlValue(type);
  594.         
  595.         return sfHookNullEvent;
  596.     default:
  597.         return item;
  598.     }
  599. }
  600.  
  601. /*
  602.     Fills in the document record with the user chosen destination
  603. */
  604.  
  605. pascal OSErr GetFileNameToSaveAs(DPtr theDocument)
  606. {
  607. #ifndef RUNTIME
  608.     OSErr                    err;
  609.     StandardFileReply    reply;
  610.     Str255            suggestName;
  611.     Point                    where;
  612.     
  613.     where.h = where.v = -1;
  614.  
  615.     GetWTitle(theDocument->theWindow, suggestName);
  616.  
  617.     CustomPutFile(
  618.         "\pSave Document As:", suggestName, &reply,
  619.         SaveScriptDialog,
  620.         where,
  621.         SaveScriptHook,
  622.         (ModalFilterYDProcPtr) nil,
  623.         nil,
  624.         (ActivateYDProcPtr) nil,
  625.         theDocument);
  626.  
  627.     if (reply.sfGood)
  628.         switch (err = FSpDelete(&reply.sfFile)) {
  629.         case noErr:
  630.         case fnfErr:
  631.             theDocument->theFSSpec = reply.sfFile;
  632.             PLstrcpy(theDocument->theFileName, reply.sfFile.name);
  633.  
  634.             return noErr;
  635.         default:
  636.             return err;
  637.         }
  638.     else
  639.         return userCanceledErr;
  640. #else
  641.     OSErr        err;
  642.     SFReply    reply;
  643.     Str255   suggestName;
  644.     Point        where;
  645.  
  646.     where.h = where.v = 75;
  647.     
  648.     GetWTitle(theDocument->theWindow, suggestName);
  649.  
  650.     SFPutFile(
  651.         where, "\pSave Document As:", 
  652.         suggestName, (DlgHookProcPtr) nil,
  653.         &reply);
  654.     
  655.     if (reply.good) {
  656.         FSSpec    spec;
  657.         
  658.         if (err = WD2FSSpec(reply.vRefNum, reply.fName, &spec))
  659.             return err;
  660.         switch (err = HDelete(spec.vRefNum, spec.parID, spec.name)) {
  661.         case noErr:
  662.         case fnfErr:
  663.             theDocument->theFSSpec = spec;
  664.             PLstrcpy(theDocument->theFileName, spec.name);
  665.  
  666.             return noErr;
  667.         default:
  668.             return err;
  669.         }
  670.     } else
  671.         return userCanceledErr;
  672. #endif
  673. } /* GetFileNameToSaveAs */
  674.  
  675. #pragma segment File
  676.  
  677. pascal OSErr OpenOld(FSSpec aFSSpec, DocType type)
  678. {
  679.     DPtr          theDocument;
  680.     OSErr         fileErr;
  681.     
  682.     theDocument = NewDocument(true, kDocumentWindow);
  683.  
  684.     SetWTitle(theDocument->theWindow, aFSSpec.name);
  685.  
  686.     SetPort(theDocument->theWindow);
  687.  
  688.     theDocument->theFSSpec   = aFSSpec;
  689.  
  690.     PLstrcpy(theDocument->theFileName,aFSSpec.name);
  691.  
  692.     theDocument->dirty               = false;
  693. #ifndef RUNTIME
  694.     theDocument->type                    = (type == kOldRuntime6Doc) ? kRuntime6Doc : type;
  695.     theDocument->u.reg.everSaved    = (type != kOldRuntime6Doc);
  696. #else
  697.     theDocument->type                    = kPlainTextDoc;
  698.     theDocument->u.reg.everSaved    = (type == kPlainTextDoc);
  699. #endif
  700.  
  701.     fileErr = GetFileContents(aFSSpec, theDocument);
  702.  
  703.     if (!fileErr) {
  704.         ResizeWindow(theDocument);
  705.         DoShowWindow(theDocument->theWindow);
  706.     } else {
  707.         if (fileErr == elvisErr) {
  708.             theDocument->u.reg.everSaved    = false;
  709. #ifdef RUNTIME
  710.             if (AEInteractWithUser(kAEDefaultTimeout, nil, nil))
  711. #endif
  712.                 if (Alert(ElvisAlert, nil) == 1)
  713.                     SaveAskingName(theDocument, true);
  714.         } else
  715.             FileError("\pError Opening ", aFSSpec.name);
  716.         
  717.         CloseMyWindow(theDocument->theWindow);
  718.     }
  719.  
  720.     return fileErr;
  721. } /* OpenOld */
  722.  
  723. pascal DocType GetDocType(FSSpec * spec)
  724. {
  725.     CInfoPBRec    info;
  726.     DocType        type    =    kUnknownDoc;
  727.     short            resFile;
  728.     short            nuFile;
  729.     OSType    **    rtType;
  730.  
  731.     if (FSpCatInfo(spec, &info))
  732.         return kUnknownDoc;
  733.     
  734.     switch (info.hFileInfo.ioFlFndrInfo.fdType) {
  735.     case 'APPL':
  736.         switch (info.hFileInfo.ioFlFndrInfo.fdCreator) {
  737.         case MPRtSig:
  738.             resFile    =    CurResFile();
  739.             nuFile    =    HOpenResFile(spec->vRefNum, spec->parID, spec->name, fsRdPerm);
  740.             
  741.             if (nuFile != -1) {
  742.                 if (rtType = (OSType **) Get1Resource('MrPL', 128))
  743.                     switch (**rtType) {
  744.                     case 'SCPT':
  745.                         type        =    kScriptDoc;
  746.                         break;
  747.                     case 'MrP7':
  748.                         type        =    kRuntime7Doc;
  749.                         break;
  750.                     case 'MrP6':
  751.                         type         =    kRuntime6Doc;
  752.                         break;
  753.                     }
  754.                     
  755.                 CloseResFile(nuFile);
  756.             }
  757.             UseResFile(resFile);
  758.             
  759.             return type;
  760.         case MPAppSig:
  761.             /* A heuristic to separate old runtimes from PowerPC executables */
  762.             if (info.hFileInfo.ioFlLgLen && info.hFileInfo.ioFlLgLen < 100000)
  763.                 return kOldRuntime6Doc; 
  764.             /* Fall through */
  765.         default:
  766.             return kUnknownDoc;
  767.         }
  768.     case 'TEXT':
  769.         return kPlainTextDoc;
  770.     case 'pref':
  771.         switch (info.hFileInfo.ioFlFndrInfo.fdCreator) {
  772.         case MPAppSig:
  773.         case MPRtSig:
  774.             return kPreferenceDoc;
  775.         }
  776.         /* Fall through */
  777.     default:
  778.         return kUnknownDoc;
  779.     }
  780. }